/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Dao;

import Dao.exceptions.IllegalOrphanException;
import Dao.exceptions.NonexistentEntityException;
import Dao.exceptions.PreexistingEntityException;
import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import Logica.EspacioDeportivo;
import Logica.Disciplina;
import Logica.Colaborador;
import Logica.Competencia;
import java.util.ArrayList;
import java.util.Collection;
import Logica.PersonaApoyo;
import Logica.Compite;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;

/**
 *
 * @author User
 */
public class CompetenciaJpaController implements Serializable {

    public CompetenciaJpaController(EntityManagerFactory emf) {
        this.emf = emf;
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Competencia competencia) throws PreexistingEntityException, Exception {
        if (competencia.getColaboradorCollection() == null) {
            competencia.setColaboradorCollection(new ArrayList<Colaborador>());
        }
        if (competencia.getPersonaApoyoCollection() == null) {
            competencia.setPersonaApoyoCollection(new ArrayList<PersonaApoyo>());
        }
        if (competencia.getCompiteCollection() == null) {
            competencia.setCompiteCollection(new ArrayList<Compite>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            EspacioDeportivo idEspacio = competencia.getIdEspacio();
            if (idEspacio != null) {
                idEspacio = em.getReference(idEspacio.getClass(), idEspacio.getIdEspacio());
                competencia.setIdEspacio(idEspacio);
            }
            Disciplina idDisciplina = competencia.getIdDisciplina();
            if (idDisciplina != null) {
                idDisciplina = em.getReference(idDisciplina.getClass(), idDisciplina.getIdDisciplina());
                competencia.setIdDisciplina(idDisciplina);
            }
            Collection<Colaborador> attachedColaboradorCollection = new ArrayList<Colaborador>();
            for (Colaborador colaboradorCollectionColaboradorToAttach : competencia.getColaboradorCollection()) {
                colaboradorCollectionColaboradorToAttach = em.getReference(colaboradorCollectionColaboradorToAttach.getClass(), colaboradorCollectionColaboradorToAttach.getIdColaborador());
                attachedColaboradorCollection.add(colaboradorCollectionColaboradorToAttach);
            }
            competencia.setColaboradorCollection(attachedColaboradorCollection);
            Collection<PersonaApoyo> attachedPersonaApoyoCollection = new ArrayList<PersonaApoyo>();
            for (PersonaApoyo personaApoyoCollectionPersonaApoyoToAttach : competencia.getPersonaApoyoCollection()) {
                personaApoyoCollectionPersonaApoyoToAttach = em.getReference(personaApoyoCollectionPersonaApoyoToAttach.getClass(), personaApoyoCollectionPersonaApoyoToAttach.getIdPersona());
                attachedPersonaApoyoCollection.add(personaApoyoCollectionPersonaApoyoToAttach);
            }
            competencia.setPersonaApoyoCollection(attachedPersonaApoyoCollection);
            Collection<Compite> attachedCompiteCollection = new ArrayList<Compite>();
            for (Compite compiteCollectionCompiteToAttach : competencia.getCompiteCollection()) {
                compiteCollectionCompiteToAttach = em.getReference(compiteCollectionCompiteToAttach.getClass(), compiteCollectionCompiteToAttach.getCompitePK());
                attachedCompiteCollection.add(compiteCollectionCompiteToAttach);
            }
            competencia.setCompiteCollection(attachedCompiteCollection);
            em.persist(competencia);
            if (idEspacio != null) {
                idEspacio.getCompetenciaCollection().add(competencia);
                idEspacio = em.merge(idEspacio);
            }
            if (idDisciplina != null) {
                idDisciplina.getCompetenciaCollection().add(competencia);
                idDisciplina = em.merge(idDisciplina);
            }
            for (Colaborador colaboradorCollectionColaborador : competencia.getColaboradorCollection()) {
                colaboradorCollectionColaborador.getCompetenciaCollection().add(competencia);
                colaboradorCollectionColaborador = em.merge(colaboradorCollectionColaborador);
            }
            for (PersonaApoyo personaApoyoCollectionPersonaApoyo : competencia.getPersonaApoyoCollection()) {
                personaApoyoCollectionPersonaApoyo.getCompetenciaCollection().add(competencia);
                personaApoyoCollectionPersonaApoyo = em.merge(personaApoyoCollectionPersonaApoyo);
            }
            for (Compite compiteCollectionCompite : competencia.getCompiteCollection()) {
                Competencia oldCompetenciaOfCompiteCollectionCompite = compiteCollectionCompite.getCompetencia();
                compiteCollectionCompite.setCompetencia(competencia);
                compiteCollectionCompite = em.merge(compiteCollectionCompite);
                if (oldCompetenciaOfCompiteCollectionCompite != null) {
                    oldCompetenciaOfCompiteCollectionCompite.getCompiteCollection().remove(compiteCollectionCompite);
                    oldCompetenciaOfCompiteCollectionCompite = em.merge(oldCompetenciaOfCompiteCollectionCompite);
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            if (findCompetencia(competencia.getIdCompetencia()) != null) {
                throw new PreexistingEntityException("Competencia " + competencia + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Competencia competencia) throws IllegalOrphanException, NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Competencia persistentCompetencia = em.find(Competencia.class, competencia.getIdCompetencia());
            EspacioDeportivo idEspacioOld = persistentCompetencia.getIdEspacio();
            EspacioDeportivo idEspacioNew = competencia.getIdEspacio();
            Disciplina idDisciplinaOld = persistentCompetencia.getIdDisciplina();
            Disciplina idDisciplinaNew = competencia.getIdDisciplina();
            Collection<Colaborador> colaboradorCollectionOld = persistentCompetencia.getColaboradorCollection();
            Collection<Colaborador> colaboradorCollectionNew = competencia.getColaboradorCollection();
            Collection<PersonaApoyo> personaApoyoCollectionOld = persistentCompetencia.getPersonaApoyoCollection();
            Collection<PersonaApoyo> personaApoyoCollectionNew = competencia.getPersonaApoyoCollection();
            Collection<Compite> compiteCollectionOld = persistentCompetencia.getCompiteCollection();
            Collection<Compite> compiteCollectionNew = competencia.getCompiteCollection();
            List<String> illegalOrphanMessages = null;
            for (Compite compiteCollectionOldCompite : compiteCollectionOld) {
                if (!compiteCollectionNew.contains(compiteCollectionOldCompite)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Compite " + compiteCollectionOldCompite + " since its competencia field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (idEspacioNew != null) {
                idEspacioNew = em.getReference(idEspacioNew.getClass(), idEspacioNew.getIdEspacio());
                competencia.setIdEspacio(idEspacioNew);
            }
            if (idDisciplinaNew != null) {
                idDisciplinaNew = em.getReference(idDisciplinaNew.getClass(), idDisciplinaNew.getIdDisciplina());
                competencia.setIdDisciplina(idDisciplinaNew);
            }
            Collection<Colaborador> attachedColaboradorCollectionNew = new ArrayList<Colaborador>();
            for (Colaborador colaboradorCollectionNewColaboradorToAttach : colaboradorCollectionNew) {
                colaboradorCollectionNewColaboradorToAttach = em.getReference(colaboradorCollectionNewColaboradorToAttach.getClass(), colaboradorCollectionNewColaboradorToAttach.getIdColaborador());
                attachedColaboradorCollectionNew.add(colaboradorCollectionNewColaboradorToAttach);
            }
            colaboradorCollectionNew = attachedColaboradorCollectionNew;
            competencia.setColaboradorCollection(colaboradorCollectionNew);
            Collection<PersonaApoyo> attachedPersonaApoyoCollectionNew = new ArrayList<PersonaApoyo>();
            for (PersonaApoyo personaApoyoCollectionNewPersonaApoyoToAttach : personaApoyoCollectionNew) {
                personaApoyoCollectionNewPersonaApoyoToAttach = em.getReference(personaApoyoCollectionNewPersonaApoyoToAttach.getClass(), personaApoyoCollectionNewPersonaApoyoToAttach.getIdPersona());
                attachedPersonaApoyoCollectionNew.add(personaApoyoCollectionNewPersonaApoyoToAttach);
            }
            personaApoyoCollectionNew = attachedPersonaApoyoCollectionNew;
            competencia.setPersonaApoyoCollection(personaApoyoCollectionNew);
            Collection<Compite> attachedCompiteCollectionNew = new ArrayList<Compite>();
            for (Compite compiteCollectionNewCompiteToAttach : compiteCollectionNew) {
                compiteCollectionNewCompiteToAttach = em.getReference(compiteCollectionNewCompiteToAttach.getClass(), compiteCollectionNewCompiteToAttach.getCompitePK());
                attachedCompiteCollectionNew.add(compiteCollectionNewCompiteToAttach);
            }
            compiteCollectionNew = attachedCompiteCollectionNew;
            competencia.setCompiteCollection(compiteCollectionNew);
            competencia = em.merge(competencia);
            if (idEspacioOld != null && !idEspacioOld.equals(idEspacioNew)) {
                idEspacioOld.getCompetenciaCollection().remove(competencia);
                idEspacioOld = em.merge(idEspacioOld);
            }
            if (idEspacioNew != null && !idEspacioNew.equals(idEspacioOld)) {
                idEspacioNew.getCompetenciaCollection().add(competencia);
                idEspacioNew = em.merge(idEspacioNew);
            }
            if (idDisciplinaOld != null && !idDisciplinaOld.equals(idDisciplinaNew)) {
                idDisciplinaOld.getCompetenciaCollection().remove(competencia);
                idDisciplinaOld = em.merge(idDisciplinaOld);
            }
            if (idDisciplinaNew != null && !idDisciplinaNew.equals(idDisciplinaOld)) {
                idDisciplinaNew.getCompetenciaCollection().add(competencia);
                idDisciplinaNew = em.merge(idDisciplinaNew);
            }
            for (Colaborador colaboradorCollectionOldColaborador : colaboradorCollectionOld) {
                if (!colaboradorCollectionNew.contains(colaboradorCollectionOldColaborador)) {
                    colaboradorCollectionOldColaborador.getCompetenciaCollection().remove(competencia);
                    colaboradorCollectionOldColaborador = em.merge(colaboradorCollectionOldColaborador);
                }
            }
            for (Colaborador colaboradorCollectionNewColaborador : colaboradorCollectionNew) {
                if (!colaboradorCollectionOld.contains(colaboradorCollectionNewColaborador)) {
                    colaboradorCollectionNewColaborador.getCompetenciaCollection().add(competencia);
                    colaboradorCollectionNewColaborador = em.merge(colaboradorCollectionNewColaborador);
                }
            }
            for (PersonaApoyo personaApoyoCollectionOldPersonaApoyo : personaApoyoCollectionOld) {
                if (!personaApoyoCollectionNew.contains(personaApoyoCollectionOldPersonaApoyo)) {
                    personaApoyoCollectionOldPersonaApoyo.getCompetenciaCollection().remove(competencia);
                    personaApoyoCollectionOldPersonaApoyo = em.merge(personaApoyoCollectionOldPersonaApoyo);
                }
            }
            for (PersonaApoyo personaApoyoCollectionNewPersonaApoyo : personaApoyoCollectionNew) {
                if (!personaApoyoCollectionOld.contains(personaApoyoCollectionNewPersonaApoyo)) {
                    personaApoyoCollectionNewPersonaApoyo.getCompetenciaCollection().add(competencia);
                    personaApoyoCollectionNewPersonaApoyo = em.merge(personaApoyoCollectionNewPersonaApoyo);
                }
            }
            for (Compite compiteCollectionNewCompite : compiteCollectionNew) {
                if (!compiteCollectionOld.contains(compiteCollectionNewCompite)) {
                    Competencia oldCompetenciaOfCompiteCollectionNewCompite = compiteCollectionNewCompite.getCompetencia();
                    compiteCollectionNewCompite.setCompetencia(competencia);
                    compiteCollectionNewCompite = em.merge(compiteCollectionNewCompite);
                    if (oldCompetenciaOfCompiteCollectionNewCompite != null && !oldCompetenciaOfCompiteCollectionNewCompite.equals(competencia)) {
                        oldCompetenciaOfCompiteCollectionNewCompite.getCompiteCollection().remove(compiteCollectionNewCompite);
                        oldCompetenciaOfCompiteCollectionNewCompite = em.merge(oldCompetenciaOfCompiteCollectionNewCompite);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                String id = competencia.getIdCompetencia();
                if (findCompetencia(id) == null) {
                    throw new NonexistentEntityException("The competencia with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(String id) throws IllegalOrphanException, NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Competencia competencia;
            try {
                competencia = em.getReference(Competencia.class, id);
                competencia.getIdCompetencia();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The competencia with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            Collection<Compite> compiteCollectionOrphanCheck = competencia.getCompiteCollection();
            for (Compite compiteCollectionOrphanCheckCompite : compiteCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Competencia (" + competencia + ") cannot be destroyed since the Compite " + compiteCollectionOrphanCheckCompite + " in its compiteCollection field has a non-nullable competencia field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            EspacioDeportivo idEspacio = competencia.getIdEspacio();
            if (idEspacio != null) {
                idEspacio.getCompetenciaCollection().remove(competencia);
                idEspacio = em.merge(idEspacio);
            }
            Disciplina idDisciplina = competencia.getIdDisciplina();
            if (idDisciplina != null) {
                idDisciplina.getCompetenciaCollection().remove(competencia);
                idDisciplina = em.merge(idDisciplina);
            }
            Collection<Colaborador> colaboradorCollection = competencia.getColaboradorCollection();
            for (Colaborador colaboradorCollectionColaborador : colaboradorCollection) {
                colaboradorCollectionColaborador.getCompetenciaCollection().remove(competencia);
                colaboradorCollectionColaborador = em.merge(colaboradorCollectionColaborador);
            }
            Collection<PersonaApoyo> personaApoyoCollection = competencia.getPersonaApoyoCollection();
            for (PersonaApoyo personaApoyoCollectionPersonaApoyo : personaApoyoCollection) {
                personaApoyoCollectionPersonaApoyo.getCompetenciaCollection().remove(competencia);
                personaApoyoCollectionPersonaApoyo = em.merge(personaApoyoCollectionPersonaApoyo);
            }
            em.remove(competencia);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Competencia> findCompetenciaEntities() {
        return findCompetenciaEntities(true, -1, -1);
    }

    public List<Competencia> findCompetenciaEntities(int maxResults, int firstResult) {
        return findCompetenciaEntities(false, maxResults, firstResult);
    }

    private List<Competencia> findCompetenciaEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Competencia.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Competencia findCompetencia(String id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Competencia.class, id);
        } finally {
            em.close();
        }
    }

    public int getCompetenciaCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Competencia> rt = cq.from(Competencia.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
}
